// Code generated by MockGen. DO NOT EDIT.
// Source: mosn.io/mosn/pkg/types (interfaces: ABIHandler,ABI,WasmFunction,WasmInstance,WasmModule,WasmVM,WasmPlugin,WasmPluginHandler,WasmPluginWrapper,WasmManager)

// Package mock is a generated GoMock package.
package mock

import (
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	v2 "mosn.io/mosn/pkg/config/v2"
	types "mosn.io/mosn/pkg/types"
	common "mosn.io/proxy-wasm-go-host/proxywasm/common"
)

// MockABIHandler is a mock of ABIHandler interface.
type MockABIHandler struct {
	ctrl     *gomock.Controller
	recorder *MockABIHandlerMockRecorder
}

// MockABIHandlerMockRecorder is the mock recorder for MockABIHandler.
type MockABIHandlerMockRecorder struct {
	mock *MockABIHandler
}

// NewMockABIHandler creates a new mock instance.
func NewMockABIHandler(ctrl *gomock.Controller) *MockABIHandler {
	mock := &MockABIHandler{ctrl: ctrl}
	mock.recorder = &MockABIHandlerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockABIHandler) EXPECT() *MockABIHandlerMockRecorder {
	return m.recorder
}

// OnInstanceCreate mocks base method.
func (m *MockABIHandler) OnInstanceCreate(arg0 common.WasmInstance) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnInstanceCreate", arg0)
}

// OnInstanceCreate indicates an expected call of OnInstanceCreate.
func (mr *MockABIHandlerMockRecorder) OnInstanceCreate(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnInstanceCreate", reflect.TypeOf((*MockABIHandler)(nil).OnInstanceCreate), arg0)
}

// OnInstanceDestroy mocks base method.
func (m *MockABIHandler) OnInstanceDestroy(arg0 common.WasmInstance) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnInstanceDestroy", arg0)
}

// OnInstanceDestroy indicates an expected call of OnInstanceDestroy.
func (mr *MockABIHandlerMockRecorder) OnInstanceDestroy(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnInstanceDestroy", reflect.TypeOf((*MockABIHandler)(nil).OnInstanceDestroy), arg0)
}

// OnInstanceStart mocks base method.
func (m *MockABIHandler) OnInstanceStart(arg0 common.WasmInstance) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnInstanceStart", arg0)
}

// OnInstanceStart indicates an expected call of OnInstanceStart.
func (mr *MockABIHandlerMockRecorder) OnInstanceStart(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnInstanceStart", reflect.TypeOf((*MockABIHandler)(nil).OnInstanceStart), arg0)
}

// MockABI is a mock of ABI interface.
type MockABI struct {
	ctrl     *gomock.Controller
	recorder *MockABIMockRecorder
}

// MockABIMockRecorder is the mock recorder for MockABI.
type MockABIMockRecorder struct {
	mock *MockABI
}

// NewMockABI creates a new mock instance.
func NewMockABI(ctrl *gomock.Controller) *MockABI {
	mock := &MockABI{ctrl: ctrl}
	mock.recorder = &MockABIMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockABI) EXPECT() *MockABIMockRecorder {
	return m.recorder
}

// GetABIExports mocks base method.
func (m *MockABI) GetABIExports() interface{} {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetABIExports")
	ret0, _ := ret[0].(interface{})
	return ret0
}

// GetABIExports indicates an expected call of GetABIExports.
func (mr *MockABIMockRecorder) GetABIExports() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetABIExports", reflect.TypeOf((*MockABI)(nil).GetABIExports))
}

// GetABIImports mocks base method.
func (m *MockABI) GetABIImports() interface{} {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetABIImports")
	ret0, _ := ret[0].(interface{})
	return ret0
}

// GetABIImports indicates an expected call of GetABIImports.
func (mr *MockABIMockRecorder) GetABIImports() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetABIImports", reflect.TypeOf((*MockABI)(nil).GetABIImports))
}

// Name mocks base method.
func (m *MockABI) Name() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Name")
	ret0, _ := ret[0].(string)
	return ret0
}

// Name indicates an expected call of Name.
func (mr *MockABIMockRecorder) Name() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockABI)(nil).Name))
}

// OnInstanceCreate mocks base method.
func (m *MockABI) OnInstanceCreate(arg0 common.WasmInstance) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnInstanceCreate", arg0)
}

// OnInstanceCreate indicates an expected call of OnInstanceCreate.
func (mr *MockABIMockRecorder) OnInstanceCreate(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnInstanceCreate", reflect.TypeOf((*MockABI)(nil).OnInstanceCreate), arg0)
}

// OnInstanceDestroy mocks base method.
func (m *MockABI) OnInstanceDestroy(arg0 common.WasmInstance) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnInstanceDestroy", arg0)
}

// OnInstanceDestroy indicates an expected call of OnInstanceDestroy.
func (mr *MockABIMockRecorder) OnInstanceDestroy(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnInstanceDestroy", reflect.TypeOf((*MockABI)(nil).OnInstanceDestroy), arg0)
}

// OnInstanceStart mocks base method.
func (m *MockABI) OnInstanceStart(arg0 common.WasmInstance) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnInstanceStart", arg0)
}

// OnInstanceStart indicates an expected call of OnInstanceStart.
func (mr *MockABIMockRecorder) OnInstanceStart(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnInstanceStart", reflect.TypeOf((*MockABI)(nil).OnInstanceStart), arg0)
}

// SetABIImports mocks base method.
func (m *MockABI) SetABIImports(arg0 interface{}) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetABIImports", arg0)
}

// SetABIImports indicates an expected call of SetABIImports.
func (mr *MockABIMockRecorder) SetABIImports(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetABIImports", reflect.TypeOf((*MockABI)(nil).SetABIImports), arg0)
}

// MockWasmFunction is a mock of WasmFunction interface.
type MockWasmFunction struct {
	ctrl     *gomock.Controller
	recorder *MockWasmFunctionMockRecorder
}

// MockWasmFunctionMockRecorder is the mock recorder for MockWasmFunction.
type MockWasmFunctionMockRecorder struct {
	mock *MockWasmFunction
}

// NewMockWasmFunction creates a new mock instance.
func NewMockWasmFunction(ctrl *gomock.Controller) *MockWasmFunction {
	mock := &MockWasmFunction{ctrl: ctrl}
	mock.recorder = &MockWasmFunctionMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockWasmFunction) EXPECT() *MockWasmFunctionMockRecorder {
	return m.recorder
}

// Call mocks base method.
func (m *MockWasmFunction) Call(arg0 ...interface{}) (interface{}, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Call", varargs...)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Call indicates an expected call of Call.
func (mr *MockWasmFunctionMockRecorder) Call(arg0 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Call", reflect.TypeOf((*MockWasmFunction)(nil).Call), arg0...)
}

// MockWasmInstance is a mock of WasmInstance interface.
type MockWasmInstance struct {
	ctrl     *gomock.Controller
	recorder *MockWasmInstanceMockRecorder
}

// MockWasmInstanceMockRecorder is the mock recorder for MockWasmInstance.
type MockWasmInstanceMockRecorder struct {
	mock *MockWasmInstance
}

// NewMockWasmInstance creates a new mock instance.
func NewMockWasmInstance(ctrl *gomock.Controller) *MockWasmInstance {
	mock := &MockWasmInstance{ctrl: ctrl}
	mock.recorder = &MockWasmInstanceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockWasmInstance) EXPECT() *MockWasmInstanceMockRecorder {
	return m.recorder
}

// Acquire mocks base method.
func (m *MockWasmInstance) Acquire() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Acquire")
	ret0, _ := ret[0].(bool)
	return ret0
}

// Acquire indicates an expected call of Acquire.
func (mr *MockWasmInstanceMockRecorder) Acquire() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Acquire", reflect.TypeOf((*MockWasmInstance)(nil).Acquire))
}

// GetByte mocks base method.
func (m *MockWasmInstance) GetByte(arg0 uint64) (byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByte", arg0)
	ret0, _ := ret[0].(byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetByte indicates an expected call of GetByte.
func (mr *MockWasmInstanceMockRecorder) GetByte(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByte", reflect.TypeOf((*MockWasmInstance)(nil).GetByte), arg0)
}

// GetData mocks base method.
func (m *MockWasmInstance) GetData() interface{} {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetData")
	ret0, _ := ret[0].(interface{})
	return ret0
}

// GetData indicates an expected call of GetData.
func (mr *MockWasmInstanceMockRecorder) GetData() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetData", reflect.TypeOf((*MockWasmInstance)(nil).GetData))
}

// GetExportsFunc mocks base method.
func (m *MockWasmInstance) GetExportsFunc(arg0 string) (common.WasmFunction, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetExportsFunc", arg0)
	ret0, _ := ret[0].(common.WasmFunction)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetExportsFunc indicates an expected call of GetExportsFunc.
func (mr *MockWasmInstanceMockRecorder) GetExportsFunc(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExportsFunc", reflect.TypeOf((*MockWasmInstance)(nil).GetExportsFunc), arg0)
}

// GetExportsMem mocks base method.
func (m *MockWasmInstance) GetExportsMem(arg0 string) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetExportsMem", arg0)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetExportsMem indicates an expected call of GetExportsMem.
func (mr *MockWasmInstanceMockRecorder) GetExportsMem(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExportsMem", reflect.TypeOf((*MockWasmInstance)(nil).GetExportsMem), arg0)
}

// GetMemory mocks base method.
func (m *MockWasmInstance) GetMemory(arg0, arg1 uint64) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMemory", arg0, arg1)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMemory indicates an expected call of GetMemory.
func (mr *MockWasmInstanceMockRecorder) GetMemory(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMemory", reflect.TypeOf((*MockWasmInstance)(nil).GetMemory), arg0, arg1)
}

// GetModule mocks base method.
func (m *MockWasmInstance) GetModule() common.WasmModule {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetModule")
	ret0, _ := ret[0].(common.WasmModule)
	return ret0
}

// GetModule indicates an expected call of GetModule.
func (mr *MockWasmInstanceMockRecorder) GetModule() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetModule", reflect.TypeOf((*MockWasmInstance)(nil).GetModule))
}

// GetUint32 mocks base method.
func (m *MockWasmInstance) GetUint32(arg0 uint64) (uint32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUint32", arg0)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUint32 indicates an expected call of GetUint32.
func (mr *MockWasmInstanceMockRecorder) GetUint32(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUint32", reflect.TypeOf((*MockWasmInstance)(nil).GetUint32), arg0)
}

// HandleError mocks base method.
func (m *MockWasmInstance) HandleError(arg0 error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "HandleError", arg0)
}

// HandleError indicates an expected call of HandleError.
func (mr *MockWasmInstanceMockRecorder) HandleError(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleError", reflect.TypeOf((*MockWasmInstance)(nil).HandleError), arg0)
}

// Lock mocks base method.
func (m *MockWasmInstance) Lock(arg0 interface{}) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Lock", arg0)
}

// Lock indicates an expected call of Lock.
func (mr *MockWasmInstanceMockRecorder) Lock(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Lock", reflect.TypeOf((*MockWasmInstance)(nil).Lock), arg0)
}

// Malloc mocks base method.
func (m *MockWasmInstance) Malloc(arg0 int32) (uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Malloc", arg0)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Malloc indicates an expected call of Malloc.
func (mr *MockWasmInstanceMockRecorder) Malloc(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Malloc", reflect.TypeOf((*MockWasmInstance)(nil).Malloc), arg0)
}

// PutByte mocks base method.
func (m *MockWasmInstance) PutByte(arg0 uint64, arg1 byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutByte", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// PutByte indicates an expected call of PutByte.
func (mr *MockWasmInstanceMockRecorder) PutByte(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutByte", reflect.TypeOf((*MockWasmInstance)(nil).PutByte), arg0, arg1)
}

// PutMemory mocks base method.
func (m *MockWasmInstance) PutMemory(arg0, arg1 uint64, arg2 []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutMemory", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// PutMemory indicates an expected call of PutMemory.
func (mr *MockWasmInstanceMockRecorder) PutMemory(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutMemory", reflect.TypeOf((*MockWasmInstance)(nil).PutMemory), arg0, arg1, arg2)
}

// PutUint32 mocks base method.
func (m *MockWasmInstance) PutUint32(arg0 uint64, arg1 uint32) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutUint32", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// PutUint32 indicates an expected call of PutUint32.
func (mr *MockWasmInstanceMockRecorder) PutUint32(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutUint32", reflect.TypeOf((*MockWasmInstance)(nil).PutUint32), arg0, arg1)
}

// RegisterFunc mocks base method.
func (m *MockWasmInstance) RegisterImports(arg0 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterImports", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// RegisterImports indicates an expected call of RegisterImports.
func (mr *MockWasmInstanceMockRecorder) RegisterImports(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterImports", reflect.TypeOf((*MockWasmInstance)(nil).RegisterImports), arg0)
}

// Release mocks base method.
func (m *MockWasmInstance) Release() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Release")
}

// Release indicates an expected call of Release.
func (mr *MockWasmInstanceMockRecorder) Release() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Release", reflect.TypeOf((*MockWasmInstance)(nil).Release))
}

// SetData mocks base method.
func (m *MockWasmInstance) SetData(arg0 interface{}) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetData", arg0)
}

// SetData indicates an expected call of SetData.
func (mr *MockWasmInstanceMockRecorder) SetData(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetData", reflect.TypeOf((*MockWasmInstance)(nil).SetData), arg0)
}

// Start mocks base method.
func (m *MockWasmInstance) Start() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Start")
	ret0, _ := ret[0].(error)
	return ret0
}

// Start indicates an expected call of Start.
func (mr *MockWasmInstanceMockRecorder) Start() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockWasmInstance)(nil).Start))
}

// Stop mocks base method.
func (m *MockWasmInstance) Stop() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Stop")
}

// Stop indicates an expected call of Stop.
func (mr *MockWasmInstanceMockRecorder) Stop() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockWasmInstance)(nil).Stop))
}

// Unlock mocks base method.
func (m *MockWasmInstance) Unlock() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Unlock")
}

// Unlock indicates an expected call of Unlock.
func (mr *MockWasmInstanceMockRecorder) Unlock() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unlock", reflect.TypeOf((*MockWasmInstance)(nil).Unlock))
}

// MockWasmModule is a mock of WasmModule interface.
type MockWasmModule struct {
	ctrl     *gomock.Controller
	recorder *MockWasmModuleMockRecorder
}

// MockWasmModuleMockRecorder is the mock recorder for MockWasmModule.
type MockWasmModuleMockRecorder struct {
	mock *MockWasmModule
}

// NewMockWasmModule creates a new mock instance.
func NewMockWasmModule(ctrl *gomock.Controller) *MockWasmModule {
	mock := &MockWasmModule{ctrl: ctrl}
	mock.recorder = &MockWasmModuleMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockWasmModule) EXPECT() *MockWasmModuleMockRecorder {
	return m.recorder
}

// GetABINameList mocks base method.
func (m *MockWasmModule) GetABINameList() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetABINameList")
	ret0, _ := ret[0].([]string)
	return ret0
}

// GetABINameList indicates an expected call of GetABINameList.
func (mr *MockWasmModuleMockRecorder) GetABINameList() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetABINameList", reflect.TypeOf((*MockWasmModule)(nil).GetABINameList))
}

// Init mocks base method.
func (m *MockWasmModule) Init() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Init")
}

// Init indicates an expected call of Init.
func (mr *MockWasmModuleMockRecorder) Init() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockWasmModule)(nil).Init))
}

// NewInstance mocks base method.
func (m *MockWasmModule) NewInstance() common.WasmInstance {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewInstance")
	ret0, _ := ret[0].(common.WasmInstance)
	return ret0
}

// NewInstance indicates an expected call of NewInstance.
func (mr *MockWasmModuleMockRecorder) NewInstance() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewInstance", reflect.TypeOf((*MockWasmModule)(nil).NewInstance))
}

// MockWasmVM is a mock of WasmVM interface.
type MockWasmVM struct {
	ctrl     *gomock.Controller
	recorder *MockWasmVMMockRecorder
}

// MockWasmVMMockRecorder is the mock recorder for MockWasmVM.
type MockWasmVMMockRecorder struct {
	mock *MockWasmVM
}

// NewMockWasmVM creates a new mock instance.
func NewMockWasmVM(ctrl *gomock.Controller) *MockWasmVM {
	mock := &MockWasmVM{ctrl: ctrl}
	mock.recorder = &MockWasmVMMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockWasmVM) EXPECT() *MockWasmVMMockRecorder {
	return m.recorder
}

// Init mocks base method.
func (m *MockWasmVM) Init() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Init")
}

// Init indicates an expected call of Init.
func (mr *MockWasmVMMockRecorder) Init() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockWasmVM)(nil).Init))
}

// Name mocks base method.
func (m *MockWasmVM) Name() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Name")
	ret0, _ := ret[0].(string)
	return ret0
}

// Name indicates an expected call of Name.
func (mr *MockWasmVMMockRecorder) Name() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockWasmVM)(nil).Name))
}

// NewModule mocks base method.
func (m *MockWasmVM) NewModule(arg0 []byte) common.WasmModule {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewModule", arg0)
	ret0, _ := ret[0].(common.WasmModule)
	return ret0
}

// NewModule indicates an expected call of NewModule.
func (mr *MockWasmVMMockRecorder) NewModule(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewModule", reflect.TypeOf((*MockWasmVM)(nil).NewModule), arg0)
}

// Close mocks base method.
func (m *MockWasmVM) Close() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// Close indicates an expected call of Close.
func (mr *MockWasmVMMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockWasmVM)(nil).Close))
}

// MockWasmPlugin is a mock of WasmPlugin interface.
type MockWasmPlugin struct {
	ctrl     *gomock.Controller
	recorder *MockWasmPluginMockRecorder
}

// MockWasmPluginMockRecorder is the mock recorder for MockWasmPlugin.
type MockWasmPluginMockRecorder struct {
	mock *MockWasmPlugin
}

// NewMockWasmPlugin creates a new mock instance.
func NewMockWasmPlugin(ctrl *gomock.Controller) *MockWasmPlugin {
	mock := &MockWasmPlugin{ctrl: ctrl}
	mock.recorder = &MockWasmPluginMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockWasmPlugin) EXPECT() *MockWasmPluginMockRecorder {
	return m.recorder
}

// Clear mocks base method.
func (m *MockWasmPlugin) Clear() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Clear")
}

// Clear indicates an expected call of Clear.
func (mr *MockWasmPluginMockRecorder) Clear() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockWasmPlugin)(nil).Clear))
}

// EnsureInstanceNum mocks base method.
func (m *MockWasmPlugin) EnsureInstanceNum(arg0 int) int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnsureInstanceNum", arg0)
	ret0, _ := ret[0].(int)
	return ret0
}

// EnsureInstanceNum indicates an expected call of EnsureInstanceNum.
func (mr *MockWasmPluginMockRecorder) EnsureInstanceNum(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnsureInstanceNum", reflect.TypeOf((*MockWasmPlugin)(nil).EnsureInstanceNum), arg0)
}

// Exec mocks base method.
func (m *MockWasmPlugin) Exec(arg0 func(common.WasmInstance) bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Exec", arg0)
}

// Exec indicates an expected call of Exec.
func (mr *MockWasmPluginMockRecorder) Exec(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exec", reflect.TypeOf((*MockWasmPlugin)(nil).Exec), arg0)
}

// GetInstance mocks base method.
func (m *MockWasmPlugin) GetInstance() common.WasmInstance {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInstance")
	ret0, _ := ret[0].(common.WasmInstance)
	return ret0
}

// GetInstance indicates an expected call of GetInstance.
func (mr *MockWasmPluginMockRecorder) GetInstance() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstance", reflect.TypeOf((*MockWasmPlugin)(nil).GetInstance))
}

// GetPluginConfig mocks base method.
func (m *MockWasmPlugin) GetPluginConfig() v2.WasmPluginConfig {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPluginConfig")
	ret0, _ := ret[0].(v2.WasmPluginConfig)
	return ret0
}

// GetPluginConfig indicates an expected call of GetPluginConfig.
func (mr *MockWasmPluginMockRecorder) GetPluginConfig() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPluginConfig", reflect.TypeOf((*MockWasmPlugin)(nil).GetPluginConfig))
}

// GetVmConfig mocks base method.
func (m *MockWasmPlugin) GetVmConfig() v2.WasmVmConfig {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVmConfig")
	ret0, _ := ret[0].(v2.WasmVmConfig)
	return ret0
}

// GetVmConfig indicates an expected call of GetVmConfig.
func (mr *MockWasmPluginMockRecorder) GetVmConfig() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVmConfig", reflect.TypeOf((*MockWasmPlugin)(nil).GetVmConfig))
}

// InstanceNum mocks base method.
func (m *MockWasmPlugin) InstanceNum() int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstanceNum")
	ret0, _ := ret[0].(int)
	return ret0
}

// InstanceNum indicates an expected call of InstanceNum.
func (mr *MockWasmPluginMockRecorder) InstanceNum() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceNum", reflect.TypeOf((*MockWasmPlugin)(nil).InstanceNum))
}

// PluginName mocks base method.
func (m *MockWasmPlugin) PluginName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PluginName")
	ret0, _ := ret[0].(string)
	return ret0
}

// PluginName indicates an expected call of PluginName.
func (mr *MockWasmPluginMockRecorder) PluginName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PluginName", reflect.TypeOf((*MockWasmPlugin)(nil).PluginName))
}

// ReleaseInstance mocks base method.
func (m *MockWasmPlugin) ReleaseInstance(arg0 common.WasmInstance) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ReleaseInstance", arg0)
}

// ReleaseInstance indicates an expected call of ReleaseInstance.
func (mr *MockWasmPluginMockRecorder) ReleaseInstance(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseInstance", reflect.TypeOf((*MockWasmPlugin)(nil).ReleaseInstance), arg0)
}

// SetCpuLimit mocks base method.
func (m *MockWasmPlugin) SetCpuLimit(arg0 int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCpuLimit", arg0)
}

// SetCpuLimit indicates an expected call of SetCpuLimit.
func (mr *MockWasmPluginMockRecorder) SetCpuLimit(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCpuLimit", reflect.TypeOf((*MockWasmPlugin)(nil).SetCpuLimit), arg0)
}

// SetMemLimit mocks base method.
func (m *MockWasmPlugin) SetMemLimit(arg0 int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMemLimit", arg0)
}

// SetMemLimit indicates an expected call of SetMemLimit.
func (mr *MockWasmPluginMockRecorder) SetMemLimit(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMemLimit", reflect.TypeOf((*MockWasmPlugin)(nil).SetMemLimit), arg0)
}

// MockWasmPluginHandler is a mock of WasmPluginHandler interface.
type MockWasmPluginHandler struct {
	ctrl     *gomock.Controller
	recorder *MockWasmPluginHandlerMockRecorder
}

// MockWasmPluginHandlerMockRecorder is the mock recorder for MockWasmPluginHandler.
type MockWasmPluginHandlerMockRecorder struct {
	mock *MockWasmPluginHandler
}

// NewMockWasmPluginHandler creates a new mock instance.
func NewMockWasmPluginHandler(ctrl *gomock.Controller) *MockWasmPluginHandler {
	mock := &MockWasmPluginHandler{ctrl: ctrl}
	mock.recorder = &MockWasmPluginHandlerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockWasmPluginHandler) EXPECT() *MockWasmPluginHandlerMockRecorder {
	return m.recorder
}

// OnConfigUpdate mocks base method.
func (m *MockWasmPluginHandler) OnConfigUpdate(arg0 v2.WasmPluginConfig) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnConfigUpdate", arg0)
}

// OnConfigUpdate indicates an expected call of OnConfigUpdate.
func (mr *MockWasmPluginHandlerMockRecorder) OnConfigUpdate(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnConfigUpdate", reflect.TypeOf((*MockWasmPluginHandler)(nil).OnConfigUpdate), arg0)
}

// OnPluginDestroy mocks base method.
func (m *MockWasmPluginHandler) OnPluginDestroy(arg0 types.WasmPlugin) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnPluginDestroy", arg0)
}

// OnPluginDestroy indicates an expected call of OnPluginDestroy.
func (mr *MockWasmPluginHandlerMockRecorder) OnPluginDestroy(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnPluginDestroy", reflect.TypeOf((*MockWasmPluginHandler)(nil).OnPluginDestroy), arg0)
}

// OnPluginStart mocks base method.
func (m *MockWasmPluginHandler) OnPluginStart(arg0 types.WasmPlugin) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnPluginStart", arg0)
}

// OnPluginStart indicates an expected call of OnPluginStart.
func (mr *MockWasmPluginHandlerMockRecorder) OnPluginStart(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnPluginStart", reflect.TypeOf((*MockWasmPluginHandler)(nil).OnPluginStart), arg0)
}

// MockWasmPluginWrapper is a mock of WasmPluginWrapper interface.
type MockWasmPluginWrapper struct {
	ctrl     *gomock.Controller
	recorder *MockWasmPluginWrapperMockRecorder
}

// MockWasmPluginWrapperMockRecorder is the mock recorder for MockWasmPluginWrapper.
type MockWasmPluginWrapperMockRecorder struct {
	mock *MockWasmPluginWrapper
}

// NewMockWasmPluginWrapper creates a new mock instance.
func NewMockWasmPluginWrapper(ctrl *gomock.Controller) *MockWasmPluginWrapper {
	mock := &MockWasmPluginWrapper{ctrl: ctrl}
	mock.recorder = &MockWasmPluginWrapperMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockWasmPluginWrapper) EXPECT() *MockWasmPluginWrapperMockRecorder {
	return m.recorder
}

// GetConfig mocks base method.
func (m *MockWasmPluginWrapper) GetConfig() v2.WasmPluginConfig {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConfig")
	ret0, _ := ret[0].(v2.WasmPluginConfig)
	return ret0
}

// GetConfig indicates an expected call of GetConfig.
func (mr *MockWasmPluginWrapperMockRecorder) GetConfig() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfig", reflect.TypeOf((*MockWasmPluginWrapper)(nil).GetConfig))
}

// GetPlugin mocks base method.
func (m *MockWasmPluginWrapper) GetPlugin() types.WasmPlugin {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPlugin")
	ret0, _ := ret[0].(types.WasmPlugin)
	return ret0
}

// GetPlugin indicates an expected call of GetPlugin.
func (mr *MockWasmPluginWrapperMockRecorder) GetPlugin() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPlugin", reflect.TypeOf((*MockWasmPluginWrapper)(nil).GetPlugin))
}

// RegisterPluginHandler mocks base method.
func (m *MockWasmPluginWrapper) RegisterPluginHandler(arg0 types.WasmPluginHandler) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RegisterPluginHandler", arg0)
}

// RegisterPluginHandler indicates an expected call of RegisterPluginHandler.
func (mr *MockWasmPluginWrapperMockRecorder) RegisterPluginHandler(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterPluginHandler", reflect.TypeOf((*MockWasmPluginWrapper)(nil).RegisterPluginHandler), arg0)
}

// Update mocks base method.
func (m *MockWasmPluginWrapper) Update(arg0 v2.WasmPluginConfig, arg1 types.WasmPlugin) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Update", arg0, arg1)
}

// Update indicates an expected call of Update.
func (mr *MockWasmPluginWrapperMockRecorder) Update(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockWasmPluginWrapper)(nil).Update), arg0, arg1)
}

// MockWasmManager is a mock of WasmManager interface.
type MockWasmManager struct {
	ctrl     *gomock.Controller
	recorder *MockWasmManagerMockRecorder
}

// MockWasmManagerMockRecorder is the mock recorder for MockWasmManager.
type MockWasmManagerMockRecorder struct {
	mock *MockWasmManager
}

// NewMockWasmManager creates a new mock instance.
func NewMockWasmManager(ctrl *gomock.Controller) *MockWasmManager {
	mock := &MockWasmManager{ctrl: ctrl}
	mock.recorder = &MockWasmManagerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockWasmManager) EXPECT() *MockWasmManagerMockRecorder {
	return m.recorder
}

// AddOrUpdateWasm mocks base method.
func (m *MockWasmManager) AddOrUpdateWasm(arg0 v2.WasmPluginConfig) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddOrUpdateWasm", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddOrUpdateWasm indicates an expected call of AddOrUpdateWasm.
func (mr *MockWasmManagerMockRecorder) AddOrUpdateWasm(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddOrUpdateWasm", reflect.TypeOf((*MockWasmManager)(nil).AddOrUpdateWasm), arg0)
}

// GetWasmPluginWrapperByName mocks base method.
func (m *MockWasmManager) GetWasmPluginWrapperByName(arg0 string) types.WasmPluginWrapper {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWasmPluginWrapperByName", arg0)
	ret0, _ := ret[0].(types.WasmPluginWrapper)
	return ret0
}

// GetWasmPluginWrapperByName indicates an expected call of GetWasmPluginWrapperByName.
func (mr *MockWasmManagerMockRecorder) GetWasmPluginWrapperByName(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWasmPluginWrapperByName", reflect.TypeOf((*MockWasmManager)(nil).GetWasmPluginWrapperByName), arg0)
}

// UninstallWasmPluginByName mocks base method.
func (m *MockWasmManager) UninstallWasmPluginByName(arg0 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UninstallWasmPluginByName", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// UninstallWasmPluginByName indicates an expected call of UninstallWasmPluginByName.
func (mr *MockWasmManagerMockRecorder) UninstallWasmPluginByName(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UninstallWasmPluginByName", reflect.TypeOf((*MockWasmManager)(nil).UninstallWasmPluginByName), arg0)
}
